\section{Introduction}
\label{sec-introduction}

In this paper\footnote{In this paper, we assume that the reader is familiar with the
  metaobject protocol for implementing \clos{}, as described in the
  book \cite{Kiczales:1991:AMP:574212} that is dedicated to the subject.}
, by \emph{bootstrapping} a \commonlisp{} system we mean
creating some \emph{target} \commonlisp{} system by building it from
its associated source code, using various \emph{tools} and
\emph{language processors} to transform that source code into an
\emph{executable file} for some typical operating system such as
GNU/Linux.  The typical way of making such a target \commonlisp{}
system evolve through maintenance, is to modify its source code and
then restart the bootstrapping procedure to build an updated executable
file.

Not all \commonlisp{} systems are created so that they can evolve this
way.  Some systems evolve by the careful modification of an existing
\emph{executing image} which is then saved as an executable file that
can be executed as usual.

In this paper we will concentrate on the technique of bootstrapping
used with \sicl{}%
\footnote{https://github.com/robert-strandh/SICL}.

Before we can start investigating different options for bootstrapping,
we must deal with an annoying but crucial detail, namely the
definition of \emph{source code}.  The Free Software Foundation
defines it as ``the preferred form of a work for making modifications
to it''.  We agree completely with this definition.  It excludes the
use of code that was automatically produced.  In practice, it also
excludes code written directly in machine language and most code
written in assembly language, with the exception of (a) small code
fragments that can not be expressed easily in some other language, and
(b) code fragments that are part of a code generator written in some
higher-level language.

However, for it to be possible for the source code of a \commonlisp{}
system to be turned into an executable file, there must be
\emph{language processors} (i.e., compilers and/or interpreters)
available that can handle the languages that the source code is
expressed in.  The main debate when it comes to bootstrapping
techniques seems to be what is meant by \emph{available} in this
context.  A common definition seems to be something like
\emph{whatever is available on a GNU/Linux system out of the box}.

One of the consequences of such a definition of \emph{available} is
that, in order to write a \commonlisp{} system, one has to use
some programming language considered lower level than \commonlisp{}
itself.  Typically, \clanguage{} plays this role.

In this paper, we argue that one of the main reasons of the creator(s)
of a target \commonlisp{} system wanting such a system in the first
place, is that they are convinced of the virtues of this language for
writing programs.  Furthermore, \commonlisp{} is uniquely well adapted
to writing language processors.  The obvious choice for a language for
writing a \commonlisp{} system is therefore \commonlisp{} itself.
Since there is now a multitude of good \commonlisp{} implementations
available and easily installable on widely-used operating systems, we
think that \commonlisp{} should be considered to be a language for
which there are language processors \emph{available} for
bootstrapping.
